/**
 * 动态路由工具
 * 处理基于菜单数据的动态路由生成和添加（使用Mock数据）
 */

import router from '@/router'
import TOOLS from './tools'

/**
 * 已添加的动态路由名称集合
 */
const addedRoutes = new Set()

/**
 * 根据菜单数据生成路由配置
 * @param {Array} menuList - 菜单列表
 * @returns {Array} 路由配置数组
 */
export const generateRoutesFromMenu = (menuList) => {

  if (!menuList || !Array.isArray(menuList)) {
    return []
  }

  const routes = []

  /**
   * 递归创建路由配置
   * @param {Object} menu - 菜单项
   * @returns {Object} 路由配置
   */
  const createRouteConfig = (menu) => {

    // 跳过没有 menu_url 的父级菜单（只作为分组使用）
    if (!menu.menu_url && menu.children && menu.children.length > 0) {
      // 对于父级菜单，只处理子菜单
      return menu.children.map(createRouteConfig).filter(Boolean)
    }

    // 跳过没有 URL 的菜单项
    if (!menu.menu_url) {
      return null
    }

    // 动态组件加载函数 - 使用工具函数自动获取组件
    const getComponentByPath = (menuUrl, menuName) => {
      try {
        // 使用工具函数检查组件是否存在
        if (TOOLS.checkViewExists(menuUrl)) {
          const componentLoader = TOOLS.getViewLoader(menuUrl)
          // 为组件添加name属性，用于keep-alive缓存
          return () => componentLoader().then(module => {
            if (module.default && !module.default.name) {
              module.default.name = menuName
            }
            return module
          })
        }

        // 返回默认组件
        return () => import('../views/UnderDevelopment.vue')

      } catch (error) {
        console.error(`组件加载错误: ${menuUrl}`, error)
        return () => import('../views/UnderDevelopment.vue')
      }
    }

    // 移除路径开头的斜杠，因为这将作为子路由
    const routePath = menu.menu_url.startsWith('/') ? menu.menu_url.slice(1) : menu.menu_url

    const route = {
      path: routePath,
      name: `Menu${menu.id}`,
      component: getComponentByPath(menu.menu_url, menu.menu_name),
      meta: {
        title: menu.menu_name,
        icon: menu.menu_icon,
        requiresAuth: true,
        menuId: menu.id,
        level: menu.level,
        orderid: menu.orderid
      }
    }

    return route
  }

  // 处理每个菜单项
  menuList.forEach((menu) => {
    if (menu && menu.id) {
      const routeConfig = createRouteConfig(menu)
      if (routeConfig) {
        if (Array.isArray(routeConfig)) {
          // 如果返回的是数组（父级菜单的子路由），展开添加
          routes.push(...routeConfig)
        } else {
          // 如果返回的是单个路由配置
          routes.push(routeConfig)
        }
      }
    }
  })

  const finalRoutes = routes.filter(Boolean)

  return finalRoutes
}

/**
 * 添加动态路由到路由器
 * @param {Array} routes - 路由配置数组
 */
export const addDynamicRoutes = (routes) => {
  if (!routes || !Array.isArray(routes)) {
    return
  }

  routes.forEach(route => {
    if (route && route.name && !addedRoutes.has(route.name)) {
      try {
        // 检查父路由是否存在
        if (!router.hasRoute('LayoutContainer')) {
          console.error('父路由 LayoutContainer 不存在，无法添加动态路由')
          return
        }

        // 将动态路由添加为 LayoutContainer 的子路由
        router.addRoute('LayoutContainer', route)
        addedRoutes.add(route.name)

      } catch (error) {
        console.error(`添加动态路由失败: ${route.name}`, error)
      }
    }
  })
}

/**
 * 清除所有动态路由
 */
export const clearDynamicRoutes = () => {
  addedRoutes.forEach(routeName => {
    try {
      if (router.hasRoute(routeName)) {
        router.removeRoute(routeName)
      }
    } catch (error) {
      console.error(`移除动态路由失败: ${routeName}`, error)
    }
  })
  addedRoutes.clear()
}

/**
 * 根据菜单数据设置动态路由
 * @param {Array} menuList - 菜单列表
 * @param {boolean} force - 是否强制重新设置
 */
export const setupDynamicRoutes = (menuList, force = false) => {
  // 检查是否已经设置过动态路由
  if (!force && addedRoutes.size > 0) {
    return
  }

  // 如果强制重新设置，先清除现有路由
  if (force) {
    clearDynamicRoutes()
  }

  // 生成新的路由配置
  const routes = generateRoutesFromMenu(menuList)

  // 添加动态路由
  addDynamicRoutes(routes)

  return routes
}

/**
 * 强制重新设置动态路由
 * @param {Array} menuList - 菜单列表
 */
export const forceSetupDynamicRoutes = (menuList) => {
  return setupDynamicRoutes(menuList, true)
}

/**
 * 获取已添加的动态路由名称列表
 * @returns {Array} 路由名称数组
 */
export const getAddedRoutes = () => {
  return Array.from(addedRoutes)
}
